package com.lsj.text;

import com.lsj.javabean.Role;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@RunWith(SpringRunner.class)
@ContextConfiguration("classpath:spring.xml")
public class JDBCTest {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Test
    public void jdbc(){
        String sql="insert into role (name,`desc`)values(?,?)";
        //执行操作
        int row = jdbcTemplate.update(sql, "aaa", "对对对对");
        System.out.println(row);
    }

    //不确定参数
    //在进行方法定义时参数列表书写需要确定  方法的参数类型与参数的个数
    //但是有些功能实现的过程中 无法确定传入数据的类型 与个数 (Object所有类型)
    //例如 进行数据库操作时 无法确定传入sql语句中占位符的个数
    //使用不确定参数可以解决这个问题 ...
    //不确定参数功能类似于数组 只不过在进行传入时可以传入任意个数的数据
    //不确定参数限制:一个方法中仅能定义一个 ,并且必须为当前方法的最后一个参数
    public int add1(int[] arr){
        int sum=0;
        for (int i : arr) {
            sum+=i;
        }
        return sum;
    }
    //使用不确定参数
    public int add2(int... arr){
        int sum=0;
        for (int i : arr) {
            sum+=i;
        }
        return sum;
    }
    @Test
    public void add(){
       int[] arr={1,2,3,4,5,6,7};
       System.out.println(add1(arr));
       System.out.println(add2(arr));
       //System.out.println(add1(1,2,3,4,5,6,7));
        //可以理解为内部会将传入的多个数据创建数组存储使用
       System.out.println(add2(1,2,3,4,5,6,7));
       //不确定参数代表0到无穷个参数
        System.out.println(add2());
    }

    //添加
    //int update(String sql,Object... args)
    public void insert(){
        String sql="insert into role (name,`desc`)values(?,?)";
        jdbcTemplate.update(sql,"name","desc");
    }
    //修改
    //修改调用方法与添加一致
    @Test
    public void update(){
        String sql="update role set name=? where rid=?";
        jdbcTemplate.update(sql,"lisi",8);
    }
    //删除
    @Test
    public void delete(){
        String sql="delete from role where rid=?";
        jdbcTemplate.update(sql,8);
    }

    //聚合查询返回单个数据
    //根据参数传入的对象类型返回数据
    //E queryForObject(String sql,Class<E>,Object... args)
    @Test
    public void count(){
        String sql="select count(*) from role";
        Long aLong = jdbcTemplate.queryForObject(sql, Long.class);
        System.out.println(aLong);
    }

    //查询返回单条数据
    //还是使用 queryForObject 只不过使用的是重载方法
    //因为需要使用自定义类型接收
    //E queryForObject(String sql,RowMapper<E> rm,Object... args)
    //RowMapper是行映射接口 用于配置查询结果与类型之间的关系
    @Test
    public void one1(){
        String sql="select * from role where rid=?";
        //BeanPropertyRowMapper是RowMapper接口的实现类
        //会自动根据传入的对象类型进行映射(自动映射)
        RowMapper<Role> rm=new BeanPropertyRowMapper<>(Role.class);
        Role role = jdbcTemplate.queryForObject(sql, rm, 1);
        System.out.println(role);
    }
    @Test
    public void one2(){
        String sql="select rid,name rname,`desc` rdesc from role where rid=?";
        //RowMapper<Role> rm=new BeanPropertyRowMapper<>(Role.class);
        //如果查询结果集与属性不匹配 需要我们自己进行映射
        RowMapper<Role> rm=new RowMapper<Role>() {
            @Override
            public Role mapRow(ResultSet resultSet, int i) throws SQLException {
                //自己取出数据
                int rid = resultSet.getInt("rid");
                String name = resultSet.getString("rname");
                String desc = resultSet.getString("rdesc");
                Role r=new Role(rid,name,desc);
                return r;
            }
        };
        Role role = jdbcTemplate.queryForObject(sql, rm, 1);
        System.out.println(role);
    }
    //查询返回多条数据
    //List<E> query(String sql,RowMapper<E> rm,Object... args)
    @Test
    public void all(){
        String sql="select * from role";
        RowMapper<Role> rm=new BeanPropertyRowMapper<>(Role.class);
        List<Role> query = jdbcTemplate.query(sql, rm);
        for (Role role : query) {
            System.out.println(role);
        }

    }
}
